home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Entertainment / MacMud / Mud 4.0 / access_check.c next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  7.7 KB  |  277 lines  |  [TEXT/MPS ]
  1. #include <sys/types.h>
  2. #include <sys/time.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5.  
  6. #include "lint.h"
  7. #include "config.h"
  8.  
  9. #ifdef ACCESS_RESTRICTED    /* Comment out whole file */
  10.  
  11. /* check a given internet address against patterns given in an ACCESS.ALLOW
  12.  * file.                       
  13.  * Written by Markus Wild for Loch Ness in 1991.
  14.  * Spread by gec with permission of Markus Wild. 
  15.  * Source is in the public domain. No charges allowed.
  16.  *
  17.  * notice the time stamp when we last scanned the file, and rescan if it
  18.  * changed since that (this enables us to edit the file without having to
  19.  * reboot lpmud to read it)
  20.  * NOTICE: when changing the access file, the old tables ARE DISCARDED. This
  21.  *         means, that users logged in will not count for the per-class
  22.  *         maximum. This will normalize, as soon as users log out, as the
  23.  *         "currently" counter will not go below 0.
  24.  */
  25.  
  26. #include <sys/stat.h>
  27. #include <sys/socket.h>
  28. #include <time.h>
  29. #include <netinet/in.h>
  30. #include <stdio.h>
  31.  
  32. extern char *inet_ntoa(), *strtok();
  33.  
  34. /* this file should better be defined in config.h ;-) */
  35. #define ACCESS_FILE "ACCESS.ALLOW"
  36.  
  37. /* log-file to show valid and rejected connections */
  38. #undef ACCESS_LOG "access.allow.log" /* simply NOT define this for NO logs*/
  39.  
  40. /* maximal string length to be output */
  41. #define MAX_MESSAGE 255
  42.  
  43. struct access_class {
  44.   int class_num;        /* the class number */
  45.   int currently;        /* currently <= this number of logged in users */
  46.   int maximum;            /* 0: disallowed, -1: no maximum */
  47.   char message[MAX_MESSAGE];    /* message to be printed in case a login can't be permitted */
  48. };
  49.  
  50. struct access_address {
  51.   int addr[4];        /* [0..255]: number, -1: all */
  52.   int hstart, hend;    /* start/end hour */
  53.   struct access_class *ac;
  54. };
  55.  
  56. static struct access_address *addr_tab = 0;
  57. static int addr_tab_index, addr_tab_size;
  58. static struct access_class *class_tab = 0;
  59. static int class_tab_index, class_tab_size;
  60. static time_t last_read = 0;
  61.  
  62. static void log_access ();
  63.  
  64. /* check the file, and if it was changed, (re)read it into memory */
  65. static void
  66. check_read_file (name)
  67.      char *name;
  68. {
  69.   struct stat stb;
  70.   FILE *in;
  71.  
  72.   if (!(stat (name, &stb)))
  73.     {
  74.       if (stb.st_mtime > last_read)
  75.     {
  76.       /* throw away the old information */
  77.       if (addr_tab) xfree ((char *)addr_tab), addr_tab = 0;
  78.       if (class_tab) xfree ((char *)class_tab), class_tab = 0;
  79.       addr_tab_size = 10;
  80.       addr_tab_index = 0;
  81.       addr_tab = (struct access_address *)
  82.           xalloc (addr_tab_size * sizeof (struct access_address));
  83.       class_tab_size = 10;
  84.       class_tab_index = 0;
  85.       class_tab = (struct access_class *)
  86.           xalloc (class_tab_size * sizeof (struct access_class));
  87.       
  88.       if (in = fopen (name, "r"))
  89.         {
  90.           while (!feof (in))
  91.         {
  92.           char buffer [2*MAX_MESSAGE]; /* heuristic ;-)) */
  93.           char addr1[4], addr2[4], addr3[4], addr4[4];
  94.           struct access_address aa;
  95.           struct access_class ac;
  96.           char *cp;
  97.           int i;
  98.  
  99.           if (! fgets (buffer, 2*MAX_MESSAGE, in)) break;
  100.           if (buffer[0] == '#') continue; /* a comment, skip */
  101.           /* if there is no ':' in there, this is probably an empty line */
  102.           if (! strchr (buffer, ':')) continue;
  103.           
  104.           /* more or less no error-checking ;-)) */
  105.           strncpy (addr1, strtok (buffer, "."), 3);
  106.           strncpy (addr2, strtok (0, "."), 3);
  107.           strncpy (addr3, strtok (0, "."), 3);
  108.           strncpy (addr4, strtok (0, ":"), 3);
  109.  
  110.           ac.class_num = atoi (strtok (0, ":"));
  111.           ac.currently = 0;
  112.           ac.maximum = atoi (((cp = strtok (0, ":")), (cp && *cp) ? cp : "0"));
  113.           aa.hstart = atoi (((cp = strtok (0, ":")), (cp && *cp) ? cp : "0"));
  114.           aa.hend   = atoi (((cp = strtok (0, ":")), (cp && *cp) ? cp : "0"));
  115.           strncpy (ac.message,
  116.                (cp = strtok (0, "\n")) ? cp : "", MAX_MESSAGE-1);
  117.  
  118.           /* check whether this class is already defined */
  119.           for (i = 0; i < class_tab_index; i++)
  120.             if (class_tab[i].class_num == ac.class_num)
  121.               {
  122.             /* in this case just set a pointer to the defined class */
  123.             aa.ac = &class_tab[i];
  124.             break;
  125.               }
  126.  
  127.           /* if not, define it */
  128.           if (i == class_tab_index)
  129.             {
  130.               class_tab[class_tab_index] = ac;
  131.               if (++class_tab_index == class_tab_size)
  132.             {
  133.               class_tab_size <<= 1;
  134.               class_tab = (struct access_class *)
  135.                   xrealloc ((char *)class_tab,
  136.                        class_tab_size * sizeof (struct access_class));
  137.             }
  138.  
  139.               aa.ac = &class_tab[i];
  140.             }
  141.  
  142.           /* now set up the address, * maps into -1, anything else is vanilla */
  143.           aa.addr[0] = strcmp(addr1, "*") ? atoi (addr1) : -1;
  144.           aa.addr[1] = strcmp(addr2, "*") ? atoi (addr2) : -1;
  145.           aa.addr[2] = strcmp(addr3, "*") ? atoi (addr3) : -1;
  146.           aa.addr[3] = strcmp(addr4, "*") ? atoi (addr4) : -1;
  147.  
  148.           /* and add it to our address table */
  149.           addr_tab[addr_tab_index] = aa;
  150.           if (++addr_tab_index == addr_tab_size)
  151.             {
  152.               addr_tab_size <<= 1;
  153.               addr_tab = (struct access_address *)
  154.               xrealloc ((char *)addr_tab,
  155.                    addr_tab_size * sizeof (struct access_address));
  156.             }
  157.         } /* over total input */
  158.           fclose (in);
  159.           last_read = stb.st_mtime;
  160.           return;
  161.         } /* if open succeeded */
  162.     }
  163.     }
  164. }
  165.  
  166. /* the main function, validate an address (peer of given socket).
  167.  * return 0, if access is not permitted, else return a pointer to the
  168.  * corresponding class. Pass that pointer on logout to "release_host_access".
  169.  */
  170. struct access_class *
  171. allow_host_access (sockfd, outfd)
  172.      int sockfd, outfd;
  173. {
  174.   struct sockaddr_in apa;
  175.   int addr[4];
  176.   int len;
  177.   char *ipname;
  178.   struct access_address *ap;
  179.   int i;
  180. #define STRING(str) str,strlen(str)
  181.   
  182.   check_read_file (ACCESS_FILE);
  183.  
  184.   len = sizeof (apa);
  185.   if (getpeername (sockfd, (struct sockaddr *)&apa, &len) == -1)
  186.     {
  187.       perror ("getpeername");
  188.       write (outfd, STRING ("Sorry, internal game error.\n"));
  189.       return 0;
  190.     }
  191.   ipname = inet_ntoa(ntohl(apa.sin_addr));
  192.   sscanf (ipname, "%d.%d.%d.%d", addr, addr + 1, addr + 2, addr + 3);
  193.  
  194.   for (i = 0, ap = addr_tab; i < addr_tab_index; i++, ap++)
  195.     {
  196.       int pos;
  197.       /* check for address. match if either equal or wildcard */
  198.       for (pos = 0; pos < 4; pos++)
  199.     if (ap->addr[pos] != addr[pos] && ap->addr[pos] != -1) break;
  200.  
  201.       if (pos == 4) /* a match */
  202.     {
  203.       /* if hstart and hend are not == 0, check whether ap is in the
  204.        * interval */
  205.       if (ap->hstart || ap->hend)
  206.         {
  207.           time_t now = time(0);
  208.           struct tm *tm = localtime(&now);
  209.           if (ap->hstart < ap->hend)
  210.         {
  211.           if (tm->tm_hour < ap->hstart || tm->tm_hour > ap->hend)
  212.             continue;
  213.         }
  214.           else
  215.         {
  216.           if (tm->tm_hour > ap->hend && tm->tm_hour < ap->hstart)
  217.             continue;
  218.         }
  219.         }
  220.  
  221.       /* no maxmium? */
  222.       if (ap->ac->maximum == -1) 
  223.             { /*gc*/
  224.               log_access (ipname, 1);
  225.               return ap->ac;
  226.             }
  227.       /* else there is a maximum, in the worst case 0 */
  228.       if (ap->ac->currently >= ap->ac->maximum)
  229.         {
  230.           write (outfd, ap->ac->message, strlen (ap->ac->message));
  231.           write (outfd, "\n", 1);
  232.           shutdown (outfd, 2); close (outfd);
  233.           log_access (ipname, 0);
  234.           return 0;
  235.         }
  236.       /* bump up the counter */
  237.       ap->ac->currently ++;
  238.       log_access (ipname, 1);
  239.       return ap->ac;
  240.     }
  241.     }
  242.  
  243.   /* default is: don't allow access */
  244.   write (outfd, STRING("Sorry, you're not allowed to use LPMUD.\n"));
  245.   shutdown (outfd, 2); close (outfd);
  246.   log_access (ipname, 0);
  247.   return 0;
  248. }
  249.  
  250. /* decrement the currently counter once. This is called, when a user loggs out. */
  251.  
  252. void
  253. release_host_access (class)
  254.      struct access_class *class;
  255. {
  256.   if (class->maximum != -1 && class->currently > 0)
  257.     -- class->currently;
  258. }
  259.  
  260. static void
  261. log_access (addr, ok)
  262.      char *addr;
  263.      int ok;
  264. {
  265. #ifdef ACCESS_LOG
  266.   FILE *log = fopen (ACCESS_LOG, "a");
  267.  
  268.   if (log)
  269.     {
  270.       fprintf (log, "%s: %s\n", addr,  ok ? "granted" : "denied");
  271.       fclose (log);
  272.     }
  273. #endif
  274. }
  275.  
  276. #endif /* ACCESS_RESTRICTED */
  277.